package com.auto.survey.util.taskqueue

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.launch
import java.util.concurrent.ConcurrentLinkedQueue

class SerialTaskQueue {
    private val taskQueue = ConcurrentLinkedQueue<suspend () -> Unit>()
    private var isProcessing = false
    private var isPaused = false  // 新增：暂停状态标志
    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())

    /**
     * 添加任务到队列
     * @param task 挂起函数形式的任务
     */
    fun addTask(task: suspend () -> Unit) {
        taskQueue.offer(task)
        if (!isProcessing && !isPaused) {
            processNextTask()
        }
    }

    /**
     * 处理队列中的下一个任务
     */
    private fun processNextTask() {
        // 如果处于暂停状态，不处理下一个任务
        if (isPaused) return

        val task = taskQueue.poll() ?: return

        isProcessing = true
        scope.launch {
            try {
                task() // 执行当前任务
            } catch (e: Exception) {
                e.printStackTrace() // 处理任务异常
            } finally {
                isProcessing = false
                // 如果未暂停且队列不为空，继续处理下一个任务
                if (!isPaused && !taskQueue.isEmpty()) {  // 修改：添加暂停状态检查
                    processNextTask()
                }
            }
        }
    }

    /**
     * 清空任务队列
     */
    fun clear() {
        taskQueue.clear()
    }

    /**
     * 暂停任务队列
     * 当前任务会继续执行，但完成后不会执行下一个任务
     */
    fun pause() {
        isPaused = true
    }

    /**
     * 继续任务队列执行
     */
    fun resume() {
        if (isPaused) {
            isPaused = false
            // 如果不在处理任务且队列不为空，开始处理下一个任务
            if (!isProcessing && !taskQueue.isEmpty()) {
                processNextTask()
            }
        }
    }

    /**
     * 取消所有任务并释放资源
     */
    fun cancelAll() {
        scope.cancel()
        clear()
        isProcessing = false
        isPaused = false  // 修改：重置暂停状态
    }

    /**
     * 获取队列中待处理的任务数量
     */
    fun size(): Int = taskQueue.size

    /**
     * 检查队列是否为空
     */
    fun isEmpty(): Boolean = taskQueue.isEmpty()

    /**
     * 判断队列是否处于暂停状态
     */
    fun isPaused() = isPaused
}